
# importar las librerías necesarias
import pandas as pd
import matplotlib.pyplot as plt
# crear el dataframe de ejemplo
datos = {'nombre': ['Ana', 'Carlos', 'Luis', 'María', 'Pedro', 'Sofía', 'Pablo', 'Lucía', 'Diego', 'Valeria'],
'ciudad': ['Madrid', 'Barcelona','Valencia', 'Sevilla', 'Málaga', 'Bilbao', 'Murcia', 'Alicante', 'Córdoba', 'Valladolid'],
'presupuesto': [500, 750, 1000, 1250, 1500, 2000, 2500, 3000, 3500, 4000]}
usuarios_df = pd.DataFrame(datos)
# imprimir el dataframe
print(usuarios_df)
# graficar los resultados
plt.bar(usuarios_df['nombre'], usuarios_df['presupuesto'])
plt.title('Presupuestos de los usuarios')
plt.xlabel('Usuarios')
plt.ylabel('Presupuesto')
plt.show()
nombre ciudad presupuesto 0 Ana Madrid 500 1 Carlos Barcelona 750 2 Luis Valencia 1000 3 María Sevilla 1250 4 Pedro Málaga 1500 5 Sofía Bilbao 2000 6 Pablo Murcia 2500 7 Lucía Alicante 3000 8 Diego Córdoba 3500 9 Valeria Valladolid 4000
import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd
# Creamos los datos
x = [1, 2, 3, 4, 5, 6, 7]
y = [10, 5, 8, 7, 2, 6, 4]
# Creamos el dataframe con los datos
df = pd.DataFrame({'x': x, 'y': y})
# Utilizamos Seaborn para el gráfico de dispersión
sns.scatterplot(data=df, x='x', y='y')
# Añadimos un título
plt.title('Gráfico de dispersión utilizando Seaborn')
# Mostramos el gráfico
plt.show()
Este código genera una gráfica de la función coseno entre 0 y 2π. Puedes cambiar la función a graficar y ajustar la configuración de la gráfica según tus necesidades.
import plotly.graph_objs as go
import numpy as np
# Definimos la función que queremos graficar
def funcion(x):
return np.cos(x)
# Generamos los puntos para la gráfica
x = np.linspace(0, 2*np.pi, 200)
y = funcion(x)
# Creamos la figura
fig = go.Figure()
# Agregamos la línea correspondiente a la función
fig.add_trace(go.Scatter(x=x, y=y, name='Función coseno'))
# Configuramos los ejes y el título de la gráfica
fig.update_layout(
xaxis_title = 'Eje x',
yaxis_title = 'Eje y',
title={
'text': 'Gráfica de la función coseno',
'y':0.9,
'x':0.5,
'xanchor': 'center',
'yanchor': 'top'}
)
# Mostramos la gráfica
fig.show()
La librería Bokeh puede ser utilizada para crear visualizaciones interactivas.
Por ejemplo, se podría crear un gráfico de dispersión interactivo que muestre la relación entre la temperatura y la precipitación en diferentes ciudades a lo largo de un período de tiempo. El usuario podría hacer clic en puntos individuales para ver más información sobre cada ciudad, como la población y el clima promedio. También se podría crear un mapa interactivo que muestre la ubicación de las tiendas de una cadena de tiendas en todo el país, permitiendo al usuario filtrar por ubicación y ver detalles específicos de cada tienda.
Este código creará un gráfico con una línea y puntos dibujados en él, y lo guardará en un archivo HTML llamado "grafico.html", que se abrirá automáticamente en tu navegador predeterminado. Sin embargo, hay muchas más características y opciones que puedes utilizar con la librería Bokeh para crear gráficos más complejos y personalizados.
from bokeh.plotting import figure, output_file, show
# Crear una lista de datos
x = [1, 2, 3, 4, 5]
y = [6, 7, 2, 4, 5]
# Crear una figura con título y etiquetas de eje
fig = figure(title="Ejemplo de gráfico de Bokeh", x_axis_label='X', y_axis_label='Y')
# Agregar datos a la figura
fig.line(x, y, legend_label="Linea", line_width=2)
fig.circle(x, y, legend_label="Puntos", size=10)
# Definir la salida del gráfico a un archivo HTML
output_file("grafico.html")
# Mostrar el gráfico
show(fig)
# al ejecutar este codigo se abrirá el navegador mostrando el gráfico en un HTML
Este ejemplo utiliza datos de automóviles de la librería vega_datasets. Estos datos se representan gráficamente en cuatro gráficos de dispersión, cada uno con una variable diferente en el eje x y la eficiencia de combustible en el eje y. La interacción entre estos gráficos está habilitada por la selección de intervalos, lo que permite al usuario seleccionar subconjuntos específicos de los datos y analizarlos en detalle.
import altair as alt
from vega_datasets import data
source = data.cars()
chart = alt.Chart(source).mark_point().encode(
x='Horsepower',
y='Miles_per_Gallon',
color='Origin',
)
# Mostrar el gráfico utilizando display
display(chart)
import scipy.integrate as spi
def f(x):
return x**2 + 3*x + 2
result, error = spi.quad(f, 0, 2)
print("El valor de la integral es:", result)
El valor de la integral es: 12.666666666666666
7 x + y - z = 1
x - y + z = 2
3x + 2y + z = 3
import numpy as np
import scipy.linalg as la
A = np.array([[7, 1, -1], [1, -1, 1], [3, 2, 1]])
b = np.array([1, 2, 3])
x = la.solve(A, b)
print("La solución del sistema es:",x)
La solución del sistema es: [0.375 0.08333333 1.70833333]
Supongamos que queremos generar una señal sinusoidal de amplitud 1, frecuencia 5 Hz y duración 1 segundo. Podemos utilizar la función linspace() de NumPy para generar un vector de tiempo y luego utilizar la función sin() para generar la señal:
import numpy as np
import matplotlib.pyplot as plt
import scipy.signal as sig
# Generar el vector de tiempo
fs = 1000
t = np.linspace(0, 1, fs)
# Generar la señal sinusoidal
f = 5
x = np.sin(2 * np.pi * f * t)
# Graficar la señal
plt.plot(t, x)
plt.xlabel("Tiempo (s)")
plt.ylabel("Amplitud")
plt.show()
from sympy import *
a = Rational(1,2)
print(a)
print(a*2)
print(pi**2)
print(pi**2)
print(pi.evalf())
print((pi+exp(1)).evalf())
print(oo)
print(oo + 1)
1/2 1 pi**2 pi**2 3.14159265358979 5.85987448204884 oo oo
SIMBOLOS
x = Symbol('x')
y = Symbol('y')
x+y+x-y
MANIPULACIONES ALGEBRÁICAS
SymPy es capaz de ejecutar potentes manipulaciones algebráicas. Echaremos un vistazo a algunas de las más usadas: expandir y simplificar.
EXPANDIR
#expandir
expand((x+y)**3)
expand(x+y, complex=True)
expand(cos(x+y), trig=True)
SIMPLIFICAR
#sIMPLIFICAR UNA EXPRESIÓN ALGEBRAICA
simplify((x+x*y)/x)
Simplificación es un término vago, es por ello que existen alternativas más precisas que simplify: powsimp (simplificación de exponentes), trigsimp (para expresiones trigonométricas) , logcombine, radsimp, together.
powsimp((x+x*y))
trigsimp((cos(x)+cos(x*y))/cos(x))
together((x+x*y)/x**2)
SIGUEN LA ESTRUCTURA : -Función -Variable -Punto
limit(sin(x)/x, x, 0)
limit(x, x, oo)
limit(1/x, x, oo)
limit(x**x, x, 0)
Puedes derivar cualquier expresión SymPy usando diff(func, var)
diff(sin(x), x)
diff(sin(2*x), x)
limit((tan(x+y)-tan(x))/y, y, 0)
diff(sin(2*x), x, 1)
diff(sin(2*x), x, 2)
diff(sin(2*x), x, 3)
series(cos(x), x)
series(1/cos(x), x)
print(series(1/cos(x), x))
1 + x**2/2 + 5*x**4/24 + O(x**6)
SymPy ofrece soporte para integrales definidas o indefinidas de funciones transcendentes elementales y de funciones especiales via integrate(), que usa una potente extensión del algoritmo Risch-Norman y algo de heurística y de reconocimiento de patrones. Puedes integrar funciones elementales de la siguiente forma
integrate(6*x**5, x)
integrate(sin(x), x)
También se pueden manejar funciones especiales de forma sencilla
integrate(exp(-x**2)*erf(x), x)
Es posible calcular integrales definidas
integrate(x**3, (x, -1, 1))
integrate(sin(x), (x, 0, pi/2))
integrate(exp(-x), (x, 0, oo))
RESOLUCIÓN DE ECUACIONES
solve(x**4 - 1, x)
[-1, 1, -I, I]
solve([x + 5*y - 2, -3*x + 6*y - 15], [x, y])
{x: -3, y: 1}
RESOLUCIÓN DE ECUACIONES TRASCENDENTALES
solve(exp(x) + 1, x)
[I*pi]
ECUACIONES POLINÓMICAS
f = x**4 - 3*x**2 + 1
factor(f)
factor(f, modulus=1)
factor(f, modulus=2)
factor(f, modulus=3)
satisfiable(x & y)
{y: True, x: True}
satisfiable(x & ~x)
False
from sympy import Matrix
Matrix([[1,0], [0,1]])
A diferencia de un NumPy array, en una matriz (de Sympy) se pueden incluir también símbolos
x = Symbol('x')
y = Symbol('y')
A = Matrix([[1,x], [y,1]])
A
import sympy as sym
import numpy as np
t = symbols('t')
x = Function('x')(t)
y = Function('y')(t)
solucion = dsolve([x.diff() - y, y.diff() + x])
print(solucion)
[Eq(x(t), C1*sin(t) + C2*cos(t)), Eq(y(t), C1*cos(t) - C2*sin(t))]
EJERCICIO:
EJECUTA EL SIGUIENTE CÓDIGO Y HAZ UN ENSAYO QUE EXPLIQUE SUS PARTES
ENVIALO A development@aeonmerx.com con tu nombre en el ASUNTO PARA OBTENER UNA MASTER CLASS GRATUITA
def imprimir_materias_suspendidas(calificaciones):
calificacion_aprobatoria = 7
asignaturas_suspendidas = {}
for alumno in calificaciones:
for asignatura_con_calificacion in calificaciones[alumno]:
asignatura = asignatura_con_calificacion["asignatura"]
calificacion = asignatura_con_calificacion["calificacion"]
if asignatura not in asignaturas_suspendidas:
asignaturas_suspendidas[asignatura] = 0
if calificacion < calificacion_aprobatoria:
asignaturas_suspendidas[asignatura] += 1
for asignatura_suspendida in asignaturas_suspendidas:
conteo = asignaturas_suspendidas[asignatura_suspendida]
print(f"{asignatura_suspendida} perdida por {conteo} alumno(s)")
def obtener_alumnos_con_media(calificaciones):
sumatorias = {}
for alumno in calificaciones:
for asignatura_con_calificacion in calificaciones[alumno]:
calificacion = asignatura_con_calificacion["calificacion"]
if alumno not in sumatorias:
sumatorias[alumno] = {"sumatoria": 0, "conteo": 0}
sumatorias[alumno]["sumatoria"] += calificacion
sumatorias[alumno]["conteo"] += 1
return sumatorias
def imprimir_media(calificaciones):
sumatorias = obtener_alumnos_con_media(calificaciones)
for alumno in sumatorias:
sumatoria = sumatorias[alumno]["sumatoria"]
conteo = sumatorias[alumno]["conteo"]
media = sumatoria/conteo
print(f"{alumno} media de {media}")
def imprimir_media_nota_superior_5(calificaciones):
sumatorias = obtener_alumnos_con_media(calificaciones)
media_minima = 5
for alumno in sumatorias:
sumatoria = sumatorias[alumno]["sumatoria"]
conteo = sumatorias[alumno]["conteo"]
media = sumatoria/conteo
if media > media_minima:
print(f"{alumno} tuvo una media superior a {media_minima} ({media})")
def main():
calificaciones = {
"Alumno 1": [{"asignatura": "Latin", "calificacion": 8}, {"asignatura": "Castellano", "calificacion": 8}, {"asignatura": "Francés", "calificacion": 9}, {"asignatura": "Inglés", "calificacion": 4}],
"Alumno 2": [{"asignatura": "Latin", "calificacion": 7}, {"asignatura": "Castellano", "calificacion": 6}, {"asignatura": "Francés", "calificacion": 7}, {"asignatura": "Inglés", "calificacion": 2}],
"Alumno 3": [{"asignatura": "Latin", "calificacion": 10}, {"asignatura": "Castellano", "calificacion": 7}, {"asignatura": "Francés", "calificacion": 8}, {"asignatura": "Inglés", "calificacion": 9}],
"Alumno 4": [{"asignatura": "Latin", "calificacion": 4}, {"asignatura": "Castellano", "calificacion": 4}, {"asignatura": "Francés", "calificacion": 3}, {"asignatura": "Inglés", "calificacion": 2}],
"Alumno 5": [{"asignatura": "Latin", "calificacion": 9}, {"asignatura": "Castellano", "calificacion": 8}, {"asignatura": "Francés", "calificacion": 9}, {"asignatura": "Inglés", "calificacion": 6}],
}
imprimir_materias_suspendidas(calificaciones)
imprimir_media(calificaciones)
imprimir_media_nota_superior_5(calificaciones)
main()
Latin perdida por 1 alumno(s) Castellano perdida por 2 alumno(s) Francés perdida por 1 alumno(s) Inglés perdida por 4 alumno(s) Alumno 1 media de 7.25 Alumno 2 media de 5.5 Alumno 3 media de 8.5 Alumno 4 media de 3.25 Alumno 5 media de 8.0 Alumno 1 tuvo una media superior a 5 (7.25) Alumno 2 tuvo una media superior a 5 (5.5) Alumno 3 tuvo una media superior a 5 (8.5) Alumno 5 tuvo una media superior a 5 (8.0)
AEON MERX 2023